﻿// Autore: Mattia Barrasso

using System.Linq;
using NUnit.Framework;
using RecipesManager.Data;
using RecipesManager.Specs.Categoria;
using TechTalk.SpecFlow;

namespace RecipesManager.Specs
{
    [Binding, Scope(Feature = "ModificaCategoria")]
    public class ModificaCategoria_Steps : CategorieBDD
    {
        [BeforeScenario]
        public new void SetUpScenario()
        {
            base.SetUpScenario();
        }

        [AfterScenario]
        protected new void TearDownScenario()
        {
            base.TearDownScenario();
        }

        [Given(@"la categoria ([a-zA-Z]+) esiste")]
        public void DatoCategoriaEsiste(string categoria)
        {
            Manager.Categories.Add(categoria);
            Assert.That(Manager.Categories.Contains(categoria));
        }

        [Given(@"la categoria ([a-zA-Z]+) non esiste")]
        public void DatoCategoriaNonEsiste(string categoria)
        {
            Assert.That(!Manager.Categories.Contains(categoria));
        }

        [Given(@"modifico la categoria ([a-zA-Z]+)")]
        public void DatoModificoCategoria(string categoria)
        {
            base.NavigateToCategories();
            base.GetCategoriesUi();

            Assert.That(_categories.Items.Any(item => item.Text.Equals(categoria)));
            _categories.Select(categoria);
            Assert.That(_categories.Items.Single(item => item.Text.Equals(categoria)).IsSelected);
            base.GetSingleCategoryUi();
        }

        [Given(@"([a-zA-Z]+) ha come categorie inferiori")]
        public void DatoCategorieInferiori(string categoria, Table table)
        {
            Assert.That(Manager.Categories.Contains(categoria));
            foreach (var row in table.Rows)
            {
                if(row["Attributi"].Equals("Nome"))
                {
                    Assert.That(Manager.Categories.Contains(row["Valori"]));
                    Manager.Categories[categoria].Children.Add(row["Valori"]);
                }else
                {
                    Assert.Fail();
                }
            }
        }
        
        [Given(@"ho inserito i valori")]
        public void DatoHoInseritoIValori(Table table)
        {
            foreach (var row in table.Rows)
            {
                if (row["Attributi"].Equals("Nome"))
                {
                    _categoryName.SetValue(row["Valori"]);
                }
                else if (row["Attributi"].Equals("Sub"))
                {
                    Assert.That(_subCategories.Items.Any(item => item.Text.Equals(row["Valori"])));
                    _subCategories.Click();
                    _subCategories.Select(row["Valori"]);
                    _addSubCategory.Click();
                }
                else if (row["Attributi"].Equals("Super"))
                {
                    Assert.That(_superCategories.Items.Any(item => item.Text.Equals(row["Valori"])));
                    _superCategories.Click();
                    _superCategories.Select(row["Valori"]);
                    _addSuperCategory.Click();
                }
                else
                {
                    Assert.Fail("Table");
                }
            }
        }

        
        [When(@"salvo")]
        public void QuandoSalvo()
        {
            _saveCategory.Click();
        }
        
        [When(@"visiono le potenziali categorie superiori")]
        public void QuandoVisionoLePotenzialiCategorieSuperiori()
        {
            _superCategories.Click();
        }
        
        [When(@"visiono le potenziali categorie inferiori")]
        public void QuandoVisionoLePotenzialiCategorieInferiori()
        {
            _subCategories.Click();
        }

        [When(@"rimuovo tutte le categorie inferiori")]
        public void QuandoRimuovoTutteLeCategorieInferiori()
        {
            foreach (var item in _selectedSubCategories.Items)
            {
                _selectedSubCategories.Select(item.Text);
                _removeSubCategory.Click();
            }
        }
        
        [Then(@"l'operazione ha successo")]
        public void AlloraLOperazioneHaSuccesso()
        {
            Assert.That(MainWindow.ModalWindows().Count == 0);
        }

        [Then(@"([a-zA-Z]+) ha come categorie inferiori")]
        public void AlloraHaComeCategorieInferiori(string categoria, Table table)
        {
            Assert.That(Manager.Categories.Contains(categoria));
            foreach (var row in table.Rows)
            {
                if (row["Attributi"].Equals("Nome"))
                {
                    Assert.That(Manager.Categories[categoria].Children.Contains(row["Valori"]));
                    Assert.That(_selectedSubCategories.Items.Any(item => item.Text.Equals(row["Valori"])));
                }
                else
                {
                    Assert.Fail("Table");
                }
            }
        }
        
        [Then(@"l'operazione non ha successo")]
        public void AlloraLOperazioneNonHaSuccesso()
        {
            Assert.That(MainWindow.ModalWindows().Count != 0);
        }

        [Then(@"la categoria ([a-zA-Z]+) esiste")]
        public void AlloraLaCategoriaCarneEsiste(string categoria)
        {
            //Assert.That(Manager.Categories.Contains(categoria));
            Assert.That(_categories.Items.Any(item => item.Text.Equals(categoria)));
        }

        [Then(@"la categoria ([a-zA-Z]+) non esiste")]
        public void AlloraLaCategoriaCarneNonEsiste(string categoria)
        {
            //Assert.That(!Manager.Categories.Contains(categoria));
            Assert.That(!_categories.Items.Any(item => item.Text.Equals(categoria)));
        }

        [Then(@"la categoria ([a-zA-Z]+) non compare nelle potenziali categorie inferiori")]
        public void AlloraLaCategoriaCarneNonCompareFraLeInferioriSelezionabili(string categoria)
        {
            Assert.That(!_subCategories.Items.Any(item => item.Text.Equals(categoria)));
            /*foreach (var subCategoryItem in _subCategories.Items)
            {
                if(subCategoryItem.Text.Equals(categoria))
                {
                    Assert.Fail();
                }
            }
            Assert.Pass();*/
        }

        [Then(@"la categoria ([a-zA-Z]+) non compare nelle potenziali categorie superiori")]
        public void AlloraLaCategoriaCarneNonCompareFraLeSuperioriSelezionabili(string categoria)
        {
            Assert.That(!_superCategories.Items.Any(item => item.Text.Equals(categoria)));
        }
    }
}
